package com.technology.javase;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

//标识符（TAG） //java 53 个关键字 保留两 const(常量)  goto(跳转)
//TODO 关键字使用不熟练 以及部分含义未知
public class $Key_Work extends father implements friend {
    //大驼峰 每个单词首字母大写  常用在 类 属性 函数 命名空间
    //小驼峰 与大驼峰不同的是首单词首字母小写  常用在 变量 方法

    //变量使用原则：就近原则。尽量控制到最小范围。
    //变量类型 变量名 变量值
    //成员变量  定义在类里
//    注意：不用初始化，也会自动被初始化成默认值。
//    作用域是整个类中，类消失了，变量才释放。
    int variabless;
    int variable = 1;

    transient int smallHump = 1;
    long sum = 55l;
    String[] a = new String[]{"2,3,5"};
    ArrayList list = new ArrayList();

    private void _keyWork() throws Exception {
        //局部变量 定义在方法里，或者局部代码块中
//        注意：必须手动初始化，来分配内存。如：int i=5;
//        作用域也就是方法里或者局部代码块里，方法运行完内存就释放了
        int variables = 1;

        try {
            super.is = true;
            for (int i = 0; i < a.length; i++) {
                if (true) {
                    switch (a.length) {
                        case 5:
                            break;
                        case 6:
                            continue;
                        default:
                            System.out.println();
                    }
                } else {
                }
            }
            synchronized (this) {
            }
        } catch (Exception e) {
            throw new Exception();

        } finally {
        }
        String x = null;
        if (x instanceof String) {

        }
    }

    ;

    public static void main(String[] args) {
        A a = null;
        B b = null;
        boolean result;
        result = a instanceof A;
        //instanceog 判断一个引用类型的变量所指向的对象是否是一个类的实例
        System.out.println(result); // 结果：false null用instanceof跟任何类型比较时都是false、
    }

    private native void $___();
}

abstract class father {
    volatile boolean is = false;
    final short has = (short) 5;
    final short hass = (short) 5;

    boolean a;

    protected short $keyWork() {
        do {
        } while (has > 5);   //先执行，在判断 循环次数不确定使用
        return has;
    }


}

interface friend {
    char a = '3';
    byte aa = a;
    double e = 1.24;
    //    float eee =1.24; float 4 字节 存不下
    float ee = 1.24f; //小数默认 double 类型  float


}

interface A {
}

class B implements A {

}

class C extends B {
}

//byte(字节)    charactor(字符)    位(bit)B 比特    1byte=8bit  （java默认使用Unicode编码）//TODO ax码表
/*多行注解*/

/**
 * 文档注解
 * 类型名称    字节空间    取值范围                                         默认值    引用类型
 * 整数型     byte         1          -128到127                                       0        Byte
 * short        2          -32768到32767                   3万             0        Short
 * int          4          -2147483648到2147483647         20亿            0         Integer
 * long          8          -9223372036854775808到9223372036854775807      0          Long
 * 浮点型     float         4          单精度  1.4E-45到3.4028235E38                   0.0       Float
 * double        8          双精度 4.9E-324到1.7976931348623157E308        0.0       Double
 * 字符       char          2         0到65535                                       空 /u0000    Character
 * 布尔       boolean       1          false / true                                 false     Boolean
 */
class type {
    public static void main(String[] args) {
        long k = Long.MIN_VALUE;  //最小值
        long l = Long.MAX_VALUE;  //最大值
        System.out.println(k + "到" + l);
        System.out.println("姓名：");
        String s = new Scanner(System.in).nextLine(); //控制台输入内容
        System.out.println("姓名：" + s);

        //小到大 （隐式转换）
        Byte a = 120;
        int b = a;//直接转

        // 大到小（显式转换）
        // 需要强制类型转换
        int xx = 356;
        byte y = (byte) xx;
//        注意：小数转成整数，小数直接舍弃
        int f = 5;
        f += 2; //7
        f -= 3; //4
        f *= 3;  //12
        f /= 6;  //2
        f ++;
        f --;
        System.out.println("f:" + f);

        while (true) {
        }  //先判断，在执行  循环次数不确定使用

    }

    /** 进制前缀
     * 0x   - 16进制
     * 0    -8进制
     * \ u   -char类型，16进制  //非法转义（报错）  杠u 中间无空格
     */
}

class SwitchCase {
    public static void main(String[] args) {
        int[] ii =new int[]{33,22,43,4,25,64,6,47,74435};
        System.out.println(ii);               //[I@27bc2616
        //Arrays.toString(数组) 把数组里的数据，用逗号连接成一个字符串
        System.out.println(Arrays.toString(ii)); //[33, 22, 43, 4, 25, 64, 6, 47, 74435]
        //Arrays.sort(数组)
        //对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
        //对引用类型数组，使用优化后的合并排序算法。
        Arrays.sort(ii);
        for (int elem:ii
             ) {
            System.out.print(" "+elem);
        }
        System.out.println();
        //Arrays.copyOf(数组，新的长度)
        //把数组复制成一个指定长度的新数组。
        //新数组长度大于原数组，相当于复制，并增加位置。--数组的扩容
        //新数组长度小于原数组，相当于截取前一部分数据。--数组的缩容
        int[] min = Arrays.copyOf(ii,6);
        System.out.println(Arrays.toString(min));
        int[] max = Arrays.copyOf(ii,11);
        System.out.println(Arrays.toString(max));


//     switch    当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。

//        用来终止循环，可以用两种方式
//        break          中断当前循环 ，直接跳出这个for循环 简单粗暴
//        continue       跳出本次for循环，进入下一轮
        for (int i = 0; i < 7; i++) {//一般知道循环次数使用
            switch (i) { // i 是整数表达式，可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持
                case (1):
                    System.out.println(1);
                case (3):
                    System.out.println(3);
                case (7):
                    System.out.println(7);
                case (9):
                    System.out.println(9);
                    break;
                default:
                    System.out.println("default");
            }
        }
    }

    //99乘法表
    private void f4() {

        for (int i = 1; i < 9; i++) {//外循环，控制行，是一定的

            for (int j = 1; j <= i; j++) {//内循环，列是不固定的，是递增的
                int i1 = new Random().nextInt(100);//获取100以内的随机数
                System.out.print(i + "*" + j + "=" + i * j + " ");//保证第一行打印出来一个*，注意条件
            }
            System.out.println();

        }

    }
}


